import mysql.connector
import os
from typing import Dict, List, Any
from datetime import datetime

def quote_identifier(identifier: str) -> str:
    """将 MySQL 标识符用反引号括起来，防止特殊字符导致的语法错误"""
    return f"`{identifier.replace('`', '``')}`"

def get_mysql_metadata(host: str, user: str, password: str, database: str) -> Dict[str, List[Dict[str, Any]]]:
    """
    从 MySQL 数据库获取表结构元数据
    
    Args:
        host: MySQL 主机地址
        user: 用户名
        password: 密码
        database: 数据库名
        
    Returns:
        按表名前缀分组的表结构信息字典
    """
    # 连接到 MySQL 数据库
    mydb = mysql.connector.connect(
        host=host,
        user=user,
        password=password,
        database=database,
        autocommit=True
    )
    
    # 创建游标对象
    mycursor = mydb.cursor(buffered=True)
    
    # 获取表列表
    mycursor.execute("SHOW TABLES")
    tables = mycursor.fetchall()
    
    # 按前缀分组的表结构数据
    prefix_tables: Dict[str, List[Dict[str, Any]]] = {}
    
    # 遍历每个表，获取列信息
    for table in tables:
        table_name = table[0]
        
        # 尝试按 '_' 分割表名
        parts = table_name.split('_')
        if len(parts) >= 2:
            prefix = parts[0]
        else:
            # 尝试按空格分割表名
            parts = table_name.split()
            if len(parts) >= 2:
                prefix = parts[0]
            else:
                print(f"表名 '{table_name}' 格式不符合 A_B 或 A B，跳过")
                continue
        
        # 使用反引号引用表名，防止特殊字符导致的语法错误
        quoted_table_name = quote_identifier(table_name)
            
        # 获取表的列信息
        try:
            # 为DESCRIBE查询创建新的游标
            desc_cursor = mydb.cursor(buffered=True)
            desc_cursor.execute(f"DESCRIBE {quoted_table_name}")
            columns = desc_cursor.fetchall()
            desc_cursor.close()
        except mysql.connector.Error as err:
            print(f"获取表 {table_name} 的列信息失败: {err}")
            continue
        
        # 获取表注释
        try:
            # 为SHOW TABLE STATUS查询创建新的游标
            status_cursor = mydb.cursor(buffered=True)
            status_cursor.execute("SHOW TABLE STATUS LIKE %s", (table_name,))
            table_status = status_cursor.fetchone()
            table_comment = table_status[18] if table_status and len(table_status) > 18 else ""
            status_cursor.close()
        except mysql.connector.Error as err:
            print(f"获取表 {table_name} 的注释失败: {err}")
            table_comment = ""
        
        # 列信息转换为字典列表
        column_data = []
        for column in columns:
            column_dict = {
                'Field': column[0],
                'Type': column[1],
                'Null': column[2],
                'Key': column[3],
                'Default': column[4],
                'Extra': column[5]
            }
            column_data.append(column_dict)
        
        # 添加到前缀分组中
        if prefix not in prefix_tables:
            prefix_tables[prefix] = []
            
        prefix_tables[prefix].append({
            'name': table_name,
            'comment': table_comment,
            'columns': column_data
        })
    
    # 关闭游标和数据库连接
    mycursor.close()
    mydb.close()
    
    return prefix_tables

def generate_single_table_markdown(table: Dict[str, Any], output_dir: str = '.') -> str:
    """
    为单个表生成独立的 Markdown 文件
    
    Args:
        table: 表结构信息
        output_dir: 输出目录
        
    Returns:
        生成的文件路径
    """
    # 确保输出目录存在
    os.makedirs(output_dir, exist_ok=True)
    
    table_name = table['name']
    table_comment = table['comment']
    columns = table['columns']
    
    # 清理表名中的特殊字符，避免文件名问题
    safe_table_name = table_name.replace('/', '_').replace('\\', '_').replace(':', '_').replace('*', '_').replace('?', '_').replace('"', '_').replace('<', '_').replace('>', '_').replace('|', '_')
    
    # 创建 Markdown 文件
    md_path = os.path.join(output_dir, f"{safe_table_name}.md")
    
    with open(md_path, 'w', encoding='utf-8') as f:
        # 写入标题和基本信息
        f.write(f"# {table_name} 表结构文档\n\n")
        f.write(f"**生成时间:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
        f.write(f"**表名:** {table_name}\n\n")
        
        if table_comment:
            f.write(f"**表注释:** {table_comment}\n\n")
        else:
            f.write("**表注释:** 无\n\n")
            
        f.write(f"**字段数量:** {len(columns)}\n\n")
        f.write("---\n\n")
        
        # 表结构
        f.write("## 表结构\n\n")
        
        # 创建表格标题
        f.write("| 字段名 | 类型 | 空值 | 键 | 默认值 | 额外信息 |\n")
        f.write("|--------|------|------|----|---------|-----------|\n")
        
        # 写入每一行数据
        for column in columns:
            field = column['Field']
            type_info = column['Type']
            null_info = column['Null']
            key_info = column['Key'] if column['Key'] else '-'
            default_info = str(column['Default']) if column['Default'] is not None else '-'
            extra_info = column['Extra'] if column['Extra'] else '-'
            
            # 转义 Markdown 特殊字符
            field = field.replace('|', '\\|')
            type_info = type_info.replace('|', '\\|')
            null_info = null_info.replace('|', '\\|')
            key_info = key_info.replace('|', '\\|')
            default_info = default_info.replace('|', '\\|')
            extra_info = extra_info.replace('|', '\\|')
            
            f.write(f"| {field} | {type_info} | {null_info} | {key_info} | {default_info} | {extra_info} |\n")
        
        f.write("\n")
        
        # 添加字段说明（如果有主键、外键等特殊字段）
        special_columns = []
        for column in columns:
            if column['Key'] == 'PRI':
                special_columns.append(f"- **{column['Field']}**: 主键")
            elif column['Key'] == 'UNI':
                special_columns.append(f"- **{column['Field']}**: 唯一键")
            elif column['Key'] == 'MUL':
                special_columns.append(f"- **{column['Field']}**: 索引键")
            elif column['Extra'] and 'auto_increment' in column['Extra'].lower():
                special_columns.append(f"- **{column['Field']}**: 自增字段")
        
        if special_columns:
            f.write("## 特殊字段说明\n\n")
            for desc in special_columns:
                f.write(f"{desc}\n")
            f.write("\n")
        
        # 添加详细字段信息
        f.write("## 字段详细信息\n\n")
        for column in columns:
            field = column['Field']
            type_info = column['Type']
            null_info = column['Null']
            key_info = column['Key']
            default_info = column['Default']
            extra_info = column['Extra']
            
            f.write(f"### {field}\n\n")
            f.write(f"- **数据类型**: {type_info}\n")
            f.write(f"- **允许空值**: {'是' if null_info == 'YES' else '否'}\n")
            
            if key_info:
                key_desc = {
                    'PRI': '主键',
                    'UNI': '唯一键',
                    'MUL': '索引键'
                }.get(key_info, key_info)
                f.write(f"- **键类型**: {key_desc}\n")
            
            if default_info is not None:
                f.write(f"- **默认值**: {default_info}\n")
            
            if extra_info:
                f.write(f"- **额外信息**: {extra_info}\n")
            
            f.write("\n")
    
    return md_path

def generate_markdown(prefix: str, tables: List[Dict[str, Any]], output_dir: str = '.') -> None:
    """
    为指定前缀的表生成 Markdown 文件（保留原有功能）
    
    Args:
        prefix: 表名前缀
        tables: 表结构信息列表
        output_dir: 输出目录
    """
    # 确保输出目录存在
    os.makedirs(output_dir, exist_ok=True)
    
    # 清理前缀中的特殊字符，避免文件名问题
    safe_prefix = prefix.replace('/', '_').replace('\\', '_').replace(':', '_').replace('*', '_').replace('?', '_').replace('"', '_').replace('<', '_').replace('>', '_').replace('|', '_')
    
    # 创建 Markdown 文件
    md_path = os.path.join(output_dir, f"{safe_prefix}_表结构.md")
    
    with open(md_path, 'w', encoding='utf-8') as f:
        # 写入标题和基本信息
        f.write(f"# {prefix} 模块表结构文档\n\n")
        f.write(f"**生成时间:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
        f.write(f"**表数量:** {len(tables)}\n\n")
        f.write("---\n\n")
        
        # 生成目录
        f.write("## 目录\n\n")
        for i, table in enumerate(tables, 1):
            table_name = table['name']
            table_comment = table['comment']
            anchor = table_name.lower().replace('_', '-').replace(' ', '-')
            f.write(f"{i}. [{table_name}](#{anchor})")
            if table_comment:
                f.write(f" - {table_comment}")
            f.write("\n")
        f.write("\n---\n\n")
        
        # 遍历每个表
        for table in tables:
            table_name = table['name']
            table_comment = table['comment']
            columns = table['columns']
            
            # 表名和注释
            f.write(f"## {table_name}\n\n")
            if table_comment:
                f.write(f"**表注释:** {table_comment}\n\n")
            else:
                f.write("**表注释:** 无\n\n")
            
            # 表结构
            f.write("### 表结构\n\n")
            
            # 创建表格标题
            f.write("| 字段名 | 类型 | 空值 | 键 | 默认值 | 额外信息 |\n")
            f.write("|--------|------|------|----|---------|-----------|\n")
            
            # 写入每一行数据
            for column in columns:
                field = column['Field']
                type_info = column['Type']
                null_info = column['Null']
                key_info = column['Key'] if column['Key'] else '-'
                default_info = str(column['Default']) if column['Default'] is not None else '-'
                extra_info = column['Extra'] if column['Extra'] else '-'
                
                # 转义 Markdown 特殊字符
                field = field.replace('|', '\\|')
                type_info = type_info.replace('|', '\\|')
                null_info = null_info.replace('|', '\\|')
                key_info = key_info.replace('|', '\\|')
                default_info = default_info.replace('|', '\\|')
                extra_info = extra_info.replace('|', '\\|')
                
                f.write(f"| {field} | {type_info} | {null_info} | {key_info} | {default_info} | {extra_info} |\n")
            
            f.write("\n")
            
            # 添加字段说明（如果有主键、外键等特殊字段）
            special_columns = []
            for column in columns:
                if column['Key'] == 'PRI':
                    special_columns.append(f"- **{column['Field']}**: 主键")
                elif column['Key'] == 'UNI':
                    special_columns.append(f"- **{column['Field']}**: 唯一键")
                elif column['Key'] == 'MUL':
                    special_columns.append(f"- **{column['Field']}**: 索引键")
                elif column['Extra'] and 'auto_increment' in column['Extra'].lower():
                    special_columns.append(f"- **{column['Field']}**: 自增字段")
            
            if special_columns:
                f.write("### 特殊字段说明\n\n")
                for desc in special_columns:
                    f.write(f"{desc}\n")
                f.write("\n")
            
            f.write("---\n\n")
    
    print(f"已生成 Markdown 文件: {md_path}")

def generate_summary_markdown(prefix_tables: Dict[str, List[Dict[str, Any]]], output_dir: str = '.') -> None:
    """
    生成所有模块的汇总 Markdown 文件
    
    Args:
        prefix_tables: 按前缀分组的表结构信息
        output_dir: 输出目录
    """
    # 确保输出目录存在
    os.makedirs(output_dir, exist_ok=True)
    
    # 创建汇总 Markdown 文件
    summary_path = os.path.join(output_dir, "数据库表结构汇总.md")
    
    with open(summary_path, 'w', encoding='utf-8') as f:
        # 写入标题和基本信息
        f.write("# 数据库表结构汇总文档\n\n")
        f.write(f"**生成时间:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
        f.write(f"**模块数量:** {len(prefix_tables)}\n\n")
        
        total_tables = sum(len(tables) for tables in prefix_tables.values())
        f.write(f"**表总数:** {total_tables}\n\n")
        f.write("---\n\n")
        
        # 模块概览
        f.write("## 模块概览\n\n")
        f.write("| 模块前缀 | 表数量 | 详细文档 |\n")
        f.write("|----------|--------|-----------|\n")
        
        for prefix, tables in sorted(prefix_tables.items()):
            safe_prefix = prefix.replace('/', '_').replace('\\', '_').replace(':', '_').replace('*', '_').replace('?', '_').replace('"', '_').replace('<', '_').replace('>', '_').replace('|', '_')
            f.write(f"| {prefix} | {len(tables)} | [{prefix}_表结构.md](./{safe_prefix}_表结构.md) |\n")
        
        f.write("\n---\n\n")
        
        # 详细表列表
        f.write("## 详细表列表\n\n")
        
        for prefix, tables in sorted(prefix_tables.items()):
            f.write(f"### {prefix} 模块\n\n")
            f.write("| 表名 | 注释 | 字段数 | 详细文档 |\n")
            f.write("|------|------|--------|----------|\n")
            
            for table in tables:
                table_name = table['name']
                table_comment = table['comment'] if table['comment'] else '无'
                column_count = len(table['columns'])
                
                # 生成单个表文档的文件名
                safe_table_name = table_name.replace('/', '_').replace('\\', '_').replace(':', '_').replace('*', '_').replace('?', '_').replace('"', '_').replace('<', '_').replace('>', '_').replace('|', '_')
                
                # 转义 Markdown 特殊字符
                display_table_name = table_name.replace('|', '\\|')
                table_comment = table_comment.replace('|', '\\|')
                
                f.write(f"| {display_table_name} | {table_comment} | {column_count} | [{table_name}.md](./{safe_table_name}.md) |\n")
            
            f.write("\n")
    
    print(f"已生成汇总 Markdown 文件: {summary_path}")

def generate_field_index(prefix_tables: Dict[str, List[Dict[str, Any]]], output_dir: str = '.') -> None:
    """
    生成字段索引文档，用于快速查找字段在哪些表中存在
    
    Args:
        prefix_tables: 按前缀分组的表结构信息
        output_dir: 输出目录
    """
    # 构建字段索引
    field_index = {}
    field_types = {}
    
    for prefix, tables in prefix_tables.items():
        for table in tables:
            table_name = table['name']
            for column in table['columns']:
                field_name = column['Field']
                field_type = column['Type']
                
                if field_name not in field_index:
                    field_index[field_name] = []
                    field_types[field_name] = {}
                
                field_index[field_name].append({
                    'table': table_name,
                    'prefix': prefix,
                    'type': field_type,
                    'null': column['Null'],
                    'key': column['Key'],
                    'default': column['Default'],
                    'extra': column['Extra']
                })
                
                # 统计字段类型
                if field_type not in field_types[field_name]:
                    field_types[field_name][field_type] = 0
                field_types[field_name][field_type] += 1
    
    # 生成字段索引文档
    index_path = os.path.join(output_dir, "字段索引_RAG语料.md")
    
    with open(index_path, 'w', encoding='utf-8') as f:
        f.write("# 数据库字段索引 - RAG 语料文档\n\n")
        f.write(f"**生成时间:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
        f.write(f"**字段总数:** {len(field_index)}\n\n")
        f.write("---\n\n")
        
        # 字段统计概览
        f.write("## 字段使用统计\n\n")
        f.write("| 字段名 | 出现次数 | 使用的表数量 | 主要数据类型 |\n")
        f.write("|--------|----------|--------------|---------------|\n")
        
        for field_name in sorted(field_index.keys()):
            occurrences = len(field_index[field_name])
            unique_tables = len(set(item['table'] for item in field_index[field_name]))
            most_common_type = max(field_types[field_name].items(), key=lambda x: x[1])[0]
            
            f.write(f"| {field_name} | {occurrences} | {unique_tables} | {most_common_type} |\n")
        
        f.write("\n---\n\n")
        
        # 详细字段信息
        f.write("## 详细字段信息\n\n")
        
        for field_name in sorted(field_index.keys()):
            f.write(f"### {field_name}\n\n")
            
            # 字段基本信息
            occurrences = len(field_index[field_name])
            unique_tables = len(set(item['table'] for item in field_index[field_name]))
            f.write(f"**字段名:** {field_name}\n\n")
            f.write(f"**出现次数:** {occurrences}\n\n")
            f.write(f"**使用的表数量:** {unique_tables}\n\n")
            
            # 数据类型统计
            type_stats = field_types[field_name]
            f.write("**数据类型分布:**\n\n")
            for type_name, count in sorted(type_stats.items(), key=lambda x: x[1], reverse=True):
                f.write(f"- {type_name}: {count} 次\n")
            f.write("\n")
            
            # 使用该字段的表列表
            f.write("**包含此字段的表:**\n\n")
            f.write("| 表名 | 模块 | 数据类型 | 允许空值 | 键类型 | 默认值 |\n")
            f.write("|------|------|----------|----------|--------|--------|\n")
            
            for item in sorted(field_index[field_name], key=lambda x: (x['prefix'], x['table'])):
                table_name = item['table'].replace('|', '\\|')
                prefix = item['prefix']
                field_type = item['type'].replace('|', '\\|')
                null_info = item['null']
                key_info = item['key'] if item['key'] else '-'
                default_info = str(item['default']) if item['default'] is not None else '-'
                
                f.write(f"| {table_name} | {prefix} | {field_type} | {null_info} | {key_info} | {default_info} |\n")
            
            f.write("\n")
            
            # RAG 优化的问答格式
            f.write("**常见问题解答:**\n\n")
            f.write(f"Q: {field_name} 字段在哪些表中存在？\n")
            f.write(f"A: {field_name} 字段在以下 {unique_tables} 个表中存在：")
            table_list = sorted(set(item['table'] for item in field_index[field_name]))
            f.write(", ".join(table_list))
            f.write("。\n\n")
            
            f.write(f"Q: {field_name} 字段的数据类型是什么？\n")
            if len(type_stats) == 1:
                f.write(f"A: {field_name} 字段的数据类型是 {list(type_stats.keys())[0]}。\n\n")
            else:
                f.write(f"A: {field_name} 字段在不同表中有不同的数据类型：")
                for type_name, count in sorted(type_stats.items(), key=lambda x: x[1], reverse=True):
                    f.write(f"{type_name}（{count}个表）")
                    if type_name != list(type_stats.keys())[-1]:
                        f.write("、")
                f.write("。\n\n")
            
            f.write("---\n\n")
    
    print(f"已生成字段索引文档: {index_path}")

def generate_qa_corpus(prefix_tables: Dict[str, List[Dict[str, Any]]], output_dir: str = '.') -> None:
    """
    生成问答语料库，专为 RAG 检索优化
    
    Args:
        prefix_tables: 按前缀分组的表结构信息
        output_dir: 输出目录
    """
    qa_path = os.path.join(output_dir, "数据库问答语料库_RAG.md")
    
    with open(qa_path, 'w', encoding='utf-8') as f:
        f.write("# 数据库问答语料库 - RAG 优化\n\n")
        f.write(f"**生成时间:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
        f.write("本文档包含数据库表结构的常见问题和答案，专为 LLM RAG 检索优化。\n\n")
        f.write("---\n\n")
        
        # 统计信息
        total_tables = sum(len(tables) for tables in prefix_tables.values())
        all_fields = set()
        for tables in prefix_tables.values():
            for table in tables:
                for column in table['columns']:
                    all_fields.add(column['Field'])
        
        f.write("## 数据库概览问答\n\n")
        f.write(f"**Q: 这个数据库有多少个模块？**\n")
        f.write(f"A: 这个数据库共有 {len(prefix_tables)} 个模块，按表名前缀分组。\n\n")
        
        f.write(f"**Q: 这个数据库总共有多少张表？**\n")
        f.write(f"A: 这个数据库总共有 {total_tables} 张表。\n\n")
        
        f.write(f"**Q: 这个数据库有哪些模块？**\n")
        f.write(f"A: 数据库包含以下模块：{', '.join(sorted(prefix_tables.keys()))}。\n\n")
        
        f.write("---\n\n")
        
        # 为每个模块生成问答
        for prefix, tables in sorted(prefix_tables.items()):
            f.write(f"## {prefix} 模块问答\n\n")
            
            f.write(f"**Q: {prefix} 模块有哪些表？**\n")
            table_names = [table['name'] for table in tables]
            f.write(f"A: {prefix} 模块包含以下 {len(tables)} 张表：{', '.join(table_names)}。\n\n")
            
            f.write(f"**Q: {prefix} 模块的表结构是什么？**\n")
            f.write(f"A: {prefix} 模块的表结构如下：\n")
            for table in tables:
                f.write(f"- {table['name']}：{table['comment'] if table['comment'] else '无注释'}，包含 {len(table['columns'])} 个字段\n")
            f.write("\n")
            
            # 为每张表生成详细问答
            for table in tables:
                table_name = table['name']
                table_comment = table['comment'] if table['comment'] else '无'
                columns = table['columns']
                
                f.write(f"### {table_name} 表问答\n\n")
                
                f.write(f"**Q: {table_name} 表是做什么的？**\n")
                f.write(f"A: {table_name} 表的注释是：{table_comment}。\n\n")
                
                f.write(f"**Q: {table_name} 表有哪些字段？**\n")
                field_names = [col['Field'] for col in columns]
                f.write(f"A: {table_name} 表包含以下 {len(columns)} 个字段：{', '.join(field_names)}。\n\n")
                
                f.write(f"**Q: {table_name} 表的主键是什么？**\n")
                primary_keys = [col['Field'] for col in columns if col['Key'] == 'PRI']
                if primary_keys:
                    f.write(f"A: {table_name} 表的主键是：{', '.join(primary_keys)}。\n\n")
                else:
                    f.write(f"A: {table_name} 表没有定义主键。\n\n")
                
                f.write(f"**Q: {table_name} 表的表结构详情是什么？**\n")
                f.write(f"A: {table_name} 表的详细结构如下：\n")
                for col in columns:
                    key_desc = ""
                    if col['Key'] == 'PRI':
                        key_desc = "（主键）"
                    elif col['Key'] == 'UNI':
                        key_desc = "（唯一键）"
                    elif col['Key'] == 'MUL':
                        key_desc = "（索引键）"
                    
                    null_desc = "允许空值" if col['Null'] == 'YES' else "不允许空值"
                    default_desc = f"，默认值：{col['Default']}" if col['Default'] is not None else ""
                    
                    f.write(f"- {col['Field']}: {col['Type']}{key_desc}，{null_desc}{default_desc}\n")
                f.write("\n")
                
                # 字段类型问答
                for col in columns:
                    field_name = col['Field']
                    field_type = col['Type']
                    f.write(f"**Q: {table_name} 表的 {field_name} 字段是什么类型？**\n")
                    f.write(f"A: {table_name} 表的 {field_name} 字段类型是 {field_type}。\n\n")
                
                f.write("---\n\n")
        
        # 通用字段问答
        f.write("## 通用字段问答\n\n")
        
        # 收集所有字段信息
        field_tables = {}
        for prefix, tables in prefix_tables.items():
            for table in tables:
                for column in table['columns']:
                    field_name = column['Field']
                    if field_name not in field_tables:
                        field_tables[field_name] = []
                    field_tables[field_name].append({
                        'table': table['name'],
                        'type': column['Type'],
                        'prefix': prefix
                    })
        
        # 为常见字段生成问答
        common_fields = ['id', 'name', 'create_time', 'update_time', 'status', 'user_id', 'type']
        for field in common_fields:
            if field in field_tables:
                tables_with_field = field_tables[field]
                f.write(f"**Q: 哪些表包含 {field} 字段？**\n")
                table_list = [item['table'] for item in tables_with_field]
                f.write(f"A: 包含 {field} 字段的表有：{', '.join(table_list)}。\n\n")
    
    print(f"已生成问答语料库: {qa_path}")

def generate_type_analysis(prefix_tables: Dict[str, List[Dict[str, Any]]], output_dir: str = '.') -> None:
    """
    生成数据类型分析文档
    
    Args:
        prefix_tables: 按前缀分组的表结构信息
        output_dir: 输出目录
    """
    type_analysis_path = os.path.join(output_dir, "数据类型分析_RAG语料.md")
    
    # 统计数据类型
    type_stats = {}
    type_field_mapping = {}
    
    for prefix, tables in prefix_tables.items():
        for table in tables:
            for column in table['columns']:
                field_type = column['Type']
                field_name = column['Field']
                table_name = table['name']
                
                if field_type not in type_stats:
                    type_stats[field_type] = 0
                    type_field_mapping[field_type] = []
                
                type_stats[field_type] += 1
                type_field_mapping[field_type].append({
                    'table': table_name,
                    'field': field_name,
                    'prefix': prefix
                })
    
    with open(type_analysis_path, 'w', encoding='utf-8') as f:
        f.write("# 数据类型分析 - RAG 语料文档\n\n")
        f.write(f"**生成时间:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
        f.write("---\n\n")
        
        f.write("## 数据类型使用统计\n\n")
        f.write("| 数据类型 | 使用次数 | 使用频率 |\n")
        f.write("|----------|----------|----------|\n")
        
        total_fields = sum(type_stats.values())
        for field_type, count in sorted(type_stats.items(), key=lambda x: x[1], reverse=True):
            frequency = f"{(count/total_fields*100):.1f}%"
            f.write(f"| {field_type} | {count} | {frequency} |\n")
        
        f.write("\n---\n\n")
        
        f.write("## 数据类型详细分析\n\n")
        
        for field_type in sorted(type_stats.keys()):
            count = type_stats[field_type]
            fields = type_field_mapping[field_type]
            
            f.write(f"### {field_type}\n\n")
            f.write(f"**使用次数:** {count}\n\n")
            f.write(f"**使用此类型的字段:**\n\n")
            
            # 按表分组显示
            table_fields = {}
            for item in fields:
                table_name = item['table']
                if table_name not in table_fields:
                    table_fields[table_name] = []
                table_fields[table_name].append(item['field'])
            
            for table_name in sorted(table_fields.keys()):
                field_list = ', '.join(table_fields[table_name])
                f.write(f"- **{table_name}**: {field_list}\n")
            
            f.write("\n")
            
            # RAG 优化问答
            f.write("**相关问答:**\n\n")
            f.write(f"Q: 哪些字段使用了 {field_type} 数据类型？\n")
            f.write(f"A: 使用 {field_type} 数据类型的字段有 {count} 个，分布在以下表中：")
            unique_tables = sorted(set(item['table'] for item in fields))
            f.write(f"{', '.join(unique_tables)}。\n\n")
            
            f.write("---\n\n")
    
    print(f"已生成数据类型分析文档: {type_analysis_path}")

def main():
    # 数据库连接配置
    db_config = {
        'host': 'localhost',
        'user': 'ppm',
        'password': 'ppmpassword',
        'database': 'ppm'
    }
    
    # 输出目录
    output_dir = 'md_output'
    os.makedirs(output_dir, exist_ok=True)
    
    try:
        # 获取元数据
        print("正在连接数据库并获取表结构信息...")
        prefix_tables = get_mysql_metadata(**db_config)
        
        if not prefix_tables:
            print("未找到任何表或表名格式不符合要求")
            return
        
        print(f"发现 {len(prefix_tables)} 个模块，共 {sum(len(tables) for tables in prefix_tables.values())} 张表")
        
        # 为每个表生成独立的 Markdown 文档
        total_tables = 0
        # for prefix, tables in prefix_tables.items():
        #     print(f"正在生成 {prefix} 模块的表文档...")
        #     for table in tables:
        #         table_name = table['name']
        #         print(f"  - 正在生成 {table_name} 表的文档...")
        #         generate_single_table_markdown(table, output_dir)
        #         total_tables += 1
        
        # 为每个前缀生成模块汇总 Markdown（可选，保留原有功能）
        print("正在生成模块汇总文档...")
        # for prefix, tables in prefix_tables.items():
        #     print(f"正在生成 {prefix} 模块的汇总文档...")
        #     generate_markdown(prefix, tables, output_dir)
        
        # 生成总汇总文档
        print("正在生成总汇总文档...")
        # generate_summary_markdown(prefix_tables, output_dir)
        
        # 生成字段索引文档
        print("正在生成字段索引文档...")
        # generate_field_index(prefix_tables, output_dir)
        
        # 生成问答语料库
        print("正在生成问答语料库...")
        generate_qa_corpus(prefix_tables, output_dir)
        
        # 生成数据类型分析文档
        print("正在生成数据类型分析文档...")
        generate_type_analysis(prefix_tables, output_dir)
        
        print(f"\n所有 Markdown 文件已生成到 {output_dir} 目录")
        print("生成的文件包括:")
        print("- 数据库表结构汇总.md (总览文档)")
        print(f"- {total_tables} 个独立表文档 (每个表一个 .md 文件)")
        for prefix in prefix_tables.keys():
            safe_prefix = prefix.replace('/', '_').replace('\\', '_').replace(':', '_').replace('*', '_').replace('?', '_').replace('"', '_').replace('<', '_').replace('>', '_').replace('|', '_')
            print(f"- {safe_prefix}_表结构.md ({prefix} 模块汇总文档)")
        print("- 字段索引_RAG语料.md (字段索引文档)")
        print("- 数据库问答语料库_RAG.md (问答语料库文档)")
        print("- 数据类型分析_RAG语料.md (数据类型分析文档)")
            
    except mysql.connector.Error as err:
        print(f"数据库连接错误: {err}")
    except Exception as e:
        print(f"程序执行错误: {e}")

if __name__ == "__main__":
    main()
